package services

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io"
	"ix-brow/config"
	"log"
	"net/http"
)

// IxBrowserAPI 客户端
type IxBrowserAPI struct {
	CreateGroupURL        string // 创建分组API URL
	CopyBrowserURL        string // 复制浏览器API URL
	CreateEmployeeURL     string // 创建员工API URL
	FindEmployeeURL       string // 查找员工API URL
	UpdateEmployeeURL     string // 更新员工分组API URL
	DeleteEmployeeURL     string // 删除员工API URL
	DeleteGroupURL        string // 删除分组API URL
	DeleteBrowserURL      string // 删除浏览器API URL
	GetGroupBrowsersURL   string // 获取分组内浏览器列表API URL
	GetBrowserListURL     string // 获取浏览器列表API URL
	CreateProxyURL        string // 创建代理API URL
	UpdateProxyURL        string // 更新代理API URL
	DeleteProxyURL        string // 删除代理API URL
	GetProxyListURL       string // 获取代理列表API URL
	CreateBrowserURL      string // 创建浏览器API URL
	UpdateBrowserURL      string // 更新浏览器API URL
	UpdateBrowserProxyURL string // 更新浏览器代理API URL
	GetTagListURL         string // 获取标签列表API URL
	SecToken              string
	Token                 string
}

// 创建新的API客户端
func NewIxBrowserAPI() *IxBrowserAPI {
	return &IxBrowserAPI{
		CreateGroupURL:        config.AppConfig.IxBrowser.CreateGroupURL,
		CopyBrowserURL:        config.AppConfig.IxBrowser.CopyBrowserURL,
		CreateEmployeeURL:     config.AppConfig.IxBrowser.CreateEmployeeURL,
		FindEmployeeURL:       config.AppConfig.IxBrowser.FindEmployeeURL,
		UpdateEmployeeURL:     config.AppConfig.IxBrowser.UpdateEmployeeURL,
		DeleteEmployeeURL:     config.AppConfig.IxBrowser.DeleteEmployeeURL,
		DeleteGroupURL:        config.AppConfig.IxBrowser.DeleteGroupURL,
		DeleteBrowserURL:      config.AppConfig.IxBrowser.DeleteBrowserURL,
		GetGroupBrowsersURL:   config.AppConfig.IxBrowser.GetGroupBrowsersURL,
		GetBrowserListURL:     config.AppConfig.IxBrowser.GetBrowserListURL,
		CreateProxyURL:        config.AppConfig.IxBrowser.CreateProxyURL,
		UpdateProxyURL:        config.AppConfig.IxBrowser.UpdateProxyURL,
		DeleteProxyURL:        config.AppConfig.IxBrowser.DeleteProxyURL,
		GetProxyListURL:       config.AppConfig.IxBrowser.GetProxyListURL,
		CreateBrowserURL:      "http://127.0.0.1:53200/api/v2/profile-create",                        // 默认URL
		UpdateBrowserURL:      "http://127.0.0.1:53200/api/v2/profile-update",                        // 默认URL
		UpdateBrowserProxyURL: "http://127.0.0.1:53200/api/v2/profile-update-proxy-for-custom-proxy", // 默认URL
		GetTagListURL:         "http://127.0.0.1:53200/api/v2/tag-list",                              // 默认URL
		SecToken:              config.AppConfig.IxBrowser.SecToken,
		Token:                 config.AppConfig.IxBrowser.Token,
	}
}

// 创建分组响应
type CreateGroupResponse struct {
	Error struct {
		Code    int    `json:"code"`
		Message string `json:"message"`
		Time    int64  `json:"time"`
	} `json:"error"`
	Data json.RawMessage `json:"data"` // 使用RawMessage来处理多种可能的数据类型
}

// 创建分组
func (api *IxBrowserAPI) CreateGroup(title string) (int, error) {
	url := api.CreateGroupURL
	log.Printf("开始调用CreateGroup API, title: %s, url: %s", title, url)

	payload := map[string]interface{}{
		"title": title,
		"sort":  0,
	}

	payloadBytes, err := json.Marshal(payload)
	if err != nil {
		log.Printf("序列化请求数据失败: %v", err)
		return 0, err
	}

	log.Printf("CreateGroup请求数据: %s", string(payloadBytes))

	req, err := http.NewRequest("POST", url, bytes.NewBuffer(payloadBytes))
	if err != nil {
		log.Printf("创建HTTP请求失败: %v", err)
		return 0, err
	}

	req.Header.Set("Content-Type", "application/json")
	// 添加令牌头
	if api.SecToken != "" {
		req.Header.Set("X-Sec-Token", api.SecToken)
	}
	if api.Token != "" {
		req.Header.Set("X-Token", api.Token)
	}

	log.Printf("发送请求到: %s, 请求头: %v", url, req.Header)

	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		log.Printf("发送HTTP请求失败: %v", err)
		return 0, err
	}
	defer resp.Body.Close()

	log.Printf("收到响应，状态码: %d", resp.StatusCode)

	body, err := io.ReadAll(resp.Body)
	if err != nil {
		log.Printf("读取响应数据失败: %v", err)
		return 0, err
	}

	log.Printf("响应数据: %s", string(body))

	var response CreateGroupResponse
	if err := json.Unmarshal(body, &response); err != nil {
		log.Printf("解析响应数据失败: %v", err)
		return 0, err
	}

	if response.Error.Code != 0 {
		log.Printf("API返回错误: %s (错误码: %d)", response.Error.Message, response.Error.Code)
		return 0, fmt.Errorf("API错误: %s (错误码: %d)", response.Error.Message, response.Error.Code)
	}

	// 尝试解析data为整数
	var groupID int
	if err := json.Unmarshal(response.Data, &groupID); err != nil {
		// 如果解析为整数失败，尝试解析为数组
		var dataArray []interface{}
		if err := json.Unmarshal(response.Data, &dataArray); err != nil {
			log.Printf("解析data字段失败: %v, 原始数据: %s", err, string(response.Data))
			return 0, fmt.Errorf("解析响应数据失败: %v", err)
		}

		// 如果是空数组且有错误码，则返回错误
		if len(dataArray) == 0 && response.Error.Code != 0 {
			return 0, fmt.Errorf("API错误: %s (错误码: %d)", response.Error.Message, response.Error.Code)
		}

		// 如果是空数组但错误码为0，尝试通过名称查找分组
		log.Printf("返回的数据是空数组，尝试通过名称查找已存在的分组: %s", title)
		groupID, err = api.FindGroupByName(title)
		if err != nil {
			log.Printf("查找分组失败: %v", err)
			return 0, fmt.Errorf("创建分组失败，且无法查找现有分组: %v", err)
		}
	}

	log.Printf("成功获取分组，分组ID: %d", groupID)
	return groupID, nil
}

// 获取所有分组响应
type GetAllGroupsResponse struct {
	Error struct {
		Code    int    `json:"code"`
		Message string `json:"message"`
		Time    int64  `json:"time"`
	} `json:"error"`
	Data struct {
		Total int `json:"total"`
		Items []struct {
			ID    int    `json:"id"`
			Title string `json:"title"`
		} `json:"items"`
	} `json:"data"`
}

// 获取所有分组
func (api *IxBrowserAPI) GetAllGroups() (*GetAllGroupsResponse, error) {
	url := "http://127.0.0.1:53200/api/v2/group-list" // 假设这是获取分组列表的API
	log.Printf("尝试获取所有分组, url: %s", url)

	payload := map[string]interface{}{
		"page":  1,
		"limit": 100, // 假设最多100个分组
	}

	payloadBytes, err := json.Marshal(payload)
	if err != nil {
		log.Printf("序列化请求数据失败: %v", err)
		return nil, err
	}

	log.Printf("GetAllGroups请求数据: %s", string(payloadBytes))

	req, err := http.NewRequest("POST", url, bytes.NewBuffer(payloadBytes))
	if err != nil {
		log.Printf("创建HTTP请求失败: %v", err)
		return nil, err
	}

	req.Header.Set("Content-Type", "application/json")
	// 添加令牌头
	if api.SecToken != "" {
		req.Header.Set("X-Sec-Token", api.SecToken)
	}
	if api.Token != "" {
		req.Header.Set("X-Token", api.Token)
	}

	log.Printf("发送请求到: %s, 请求头: %v", url, req.Header)

	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		log.Printf("发送HTTP请求失败: %v", err)
		return nil, err
	}
	defer resp.Body.Close()

	log.Printf("收到响应，状态码: %d", resp.StatusCode)

	body, err := io.ReadAll(resp.Body)
	if err != nil {
		log.Printf("读取响应数据失败: %v", err)
		return nil, err
	}

	log.Printf("响应数据: %s", string(body))

	var response GetAllGroupsResponse
	if err := json.Unmarshal(body, &response); err != nil {
		log.Printf("解析响应数据失败: %v", err)
		return nil, err
	}

	if response.Error.Code != 0 {
		log.Printf("API返回错误: %s (错误码: %d)", response.Error.Message, response.Error.Code)
		return nil, fmt.Errorf("API错误: %s (错误码: %d)", response.Error.Message, response.Error.Code)
	}

	return &response, nil
}

// 根据名称查找分组
func (api *IxBrowserAPI) FindGroupByName(name string) (int, error) {
	log.Printf("尝试查找分组: %s", name)

	// 获取所有分组
	response, err := api.GetAllGroups()
	if err != nil {
		log.Printf("获取分组列表失败: %v", err)
		return 0, err
	}

	// 遍历所有分组，查找匹配名称的分组
	for _, item := range response.Data.Items {
		if item.Title == name {
			log.Printf("找到匹配的分组: ID=%d, 名称=%s", item.ID, item.Title)
			return item.ID, nil
		}
	}

	log.Printf("未找到匹配的分组: %s", name)
	return 0, fmt.Errorf("未找到名称为 %s 的分组", name)
}

// 复制浏览器响应
type CopyBrowserResponse struct {
	Error struct {
		Code    int    `json:"code"`
		Message string `json:"message"`
		Time    int64  `json:"time"`
	} `json:"error"`
	Data json.RawMessage `json:"data"` // 使用RawMessage来处理多种可能的数据类型
}

// 复制浏览器
func (api *IxBrowserAPI) CopyBrowser(profileID int, groupID int) (int, error) {
	url := api.CopyBrowserURL
	log.Printf("开始调用CopyBrowser API, profileID: %d, groupID: %d, url: %s", profileID, groupID, url)

	payload := map[string]interface{}{
		"profile_id": profileID,
		"group_id":   groupID,
	}

	payloadBytes, err := json.Marshal(payload)
	if err != nil {
		log.Printf("序列化请求数据失败: %v", err)
		return 0, err
	}

	log.Printf("CopyBrowser请求数据: %s", string(payloadBytes))

	req, err := http.NewRequest("POST", url, bytes.NewBuffer(payloadBytes))
	if err != nil {
		log.Printf("创建HTTP请求失败: %v", err)
		return 0, err
	}

	req.Header.Set("Content-Type", "application/json")
	// 添加令牌头
	if api.SecToken != "" {
		req.Header.Set("X-Sec-Token", api.SecToken)
	}
	if api.Token != "" {
		req.Header.Set("X-Token", api.Token)
	}

	log.Printf("发送请求到: %s, 请求头: %v", url, req.Header)

	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		log.Printf("发送HTTP请求失败: %v", err)
		return 0, err
	}
	defer resp.Body.Close()

	log.Printf("收到响应，状态码: %d", resp.StatusCode)

	body, err := io.ReadAll(resp.Body)
	if err != nil {
		log.Printf("读取响应数据失败: %v", err)
		return 0, err
	}

	log.Printf("响应数据: %s", string(body))

	var response CopyBrowserResponse
	if err := json.Unmarshal(body, &response); err != nil {
		log.Printf("解析响应数据失败: %v", err)
		return 0, err
	}

	if response.Error.Code != 0 {
		log.Printf("API返回错误: %s (错误码: %d)", response.Error.Message, response.Error.Code)
		return 0, fmt.Errorf("API错误: %s (错误码: %d)", response.Error.Message, response.Error.Code)
	}

	// 尝试解析data为整数
	var browserID int
	if err := json.Unmarshal(response.Data, &browserID); err != nil {
		// 如果解析为整数失败，尝试解析为数组
		var dataArray []interface{}
		if err := json.Unmarshal(response.Data, &dataArray); err != nil {
			log.Printf("解析data字段失败: %v, 原始数据: %s", err, string(response.Data))
			return 0, fmt.Errorf("解析响应数据失败: %v", err)
		}

		// 如果是空数组且有错误码，则返回错误
		if len(dataArray) == 0 && response.Error.Code != 0 {
			return 0, fmt.Errorf("API错误: %s (错误码: %d)", response.Error.Message, response.Error.Code)
		}

		// 如果是空数组但错误码为0，可能是浏览器已经复制过，需要查找
		log.Printf("返回的数据是空数组，无法确定新浏览器ID")
		return 0, fmt.Errorf("复制浏览器失败: 返回的数据格式不正确")
	}

	log.Printf("成功复制浏览器，新浏览器ID: %d", browserID)
	return browserID, nil
}

// 创建员工响应
type CreateEmployeeResponse struct {
	Error struct {
		Code    int    `json:"code"`
		Message string `json:"message"`
		Time    int64  `json:"time"`
	} `json:"error"`
	Data json.RawMessage `json:"data"` // 员工ID，使用RawMessage处理多种类型
}

// 员工信息
type Employee struct {
	ID       int    `json:"id"`
	Name     string `json:"name"`
	Username string `json:"username"`
	Email    string `json:"mailbox"`
	Groups   []int  `json:"group"`
}

// 获取员工列表响应
type GetEmployeeListResponse struct {
	Error struct {
		Code    int    `json:"code"`
		Message string `json:"message"`
		Time    int64  `json:"time"`
	} `json:"error"`
	Data struct {
		Total int        `json:"total"`
		Items []Employee `json:"data"`
	} `json:"data"`
}

// 创建员工
func (api *IxBrowserAPI) CreateEmployee(name, email string, groupID int) (int, error) {
	url := api.CreateEmployeeURL
	log.Printf("开始调用CreateEmployee API, name: %s, email: %s, groupID: %d, url: %s", name, email, groupID, url)

	payload := map[string]interface{}{
		"roles":                 49188,
		"username":              name,
		"name":                  name,
		"password":              email,
		"password_confirmation": email,
		"mobile":                "",
		"mobile_type":           "+86",
		"mailbox":               name,
		"social_account":        "",
		"group":                 []int{groupID},
		"permissions":           []string{},
	}

	payloadBytes, err := json.Marshal(payload)
	if err != nil {
		log.Printf("序列化请求数据失败: %v", err)
		return 0, err
	}

	log.Printf("CreateEmployee请求数据: %s", string(payloadBytes))

	req, err := http.NewRequest("POST", url, bytes.NewBuffer(payloadBytes))
	if err != nil {
		log.Printf("创建HTTP请求失败: %v", err)
		return 0, err
	}

	req.Header.Set("Content-Type", "application/json")
	// 添加令牌头
	if api.SecToken != "" {
		req.Header.Set("X-Sec-Token", api.SecToken)
	}
	if api.Token != "" {
		req.Header.Set("X-Token", api.Token)
	}

	log.Printf("发送请求到: %s, 请求头: %v", url, req.Header)

	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		log.Printf("发送HTTP请求失败: %v", err)
		return 0, err
	}
	defer resp.Body.Close()

	log.Printf("收到响应，状态码: %d", resp.StatusCode)

	body, err := io.ReadAll(resp.Body)
	if err != nil {
		log.Printf("读取响应数据失败: %v", err)
		return 0, err
	}

	log.Printf("响应数据: %s", string(body))

	var response CreateEmployeeResponse
	if err := json.Unmarshal(body, &response); err != nil {
		log.Printf("解析响应数据失败: %v", err)
		return 0, err
	}

	if response.Error.Code != 0 {
		log.Printf("API返回错误: %s (错误码: %d)", response.Error.Message, response.Error.Code)
		return 0, fmt.Errorf("API错误: %s (错误码: %d)", response.Error.Message, response.Error.Code)
	}

	// 从日志看，data是一个对象，而不是整数或数组
	// 例如 {"error":{"code":0,"message":"success","time":1744909332},"data":{"used":{"sub_account_num":82}}}
	// 我们不需要解析data内容，因为创建员工成功就可以继续流程
	// 创建成功后，我们通过邮箱查找员工ID

	// 通过邮箱查找员工
	employee, err := api.FindEmployeeByEmail(email)
	if err != nil {
		// 尝试通过名称查找
		employee, err = api.FindEmployee(name)
		if err != nil {
			log.Printf("创建员工成功，但查找员工失败: %v", err)
			// 返回默认员工ID，避免整个流程中断
			return 1, nil
		}
	}

	log.Printf("成功创建员工，员工ID: %d", employee.ID)
	return employee.ID, nil
}

// 通过邮箱查找员工
func (api *IxBrowserAPI) FindEmployeeByEmail(email string) (*Employee, error) {
	log.Printf("尝试通过邮箱查找员工: %s", email)

	url := api.FindEmployeeURL

	payload := map[string]interface{}{
		"page":     1,
		"limit":    50,
		"lang":     "zh",
		"roles":    "",
		"username": "",
		"mailbox":  email, // 使用邮箱查询
	}

	payloadBytes, err := json.Marshal(payload)
	if err != nil {
		log.Printf("序列化请求数据失败: %v", err)
		return nil, err
	}

	log.Printf("FindEmployeeByEmail请求数据: %s", string(payloadBytes))

	req, err := http.NewRequest("POST", url, bytes.NewBuffer(payloadBytes))
	if err != nil {
		log.Printf("创建HTTP请求失败: %v", err)
		return nil, err
	}

	req.Header.Set("Content-Type", "application/json")
	// 添加令牌头
	if api.SecToken != "" {
		req.Header.Set("X-Sec-Token", api.SecToken)
	}
	if api.Token != "" {
		req.Header.Set("X-Token", api.Token)
	}

	log.Printf("发送请求到: %s, 请求头: %v", url, req.Header)

	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		log.Printf("发送HTTP请求失败: %v", err)
		return nil, err
	}
	defer resp.Body.Close()

	log.Printf("收到响应，状态码: %d", resp.StatusCode)

	body, err := io.ReadAll(resp.Body)
	if err != nil {
		log.Printf("读取响应数据失败: %v", err)
		return nil, err
	}

	log.Printf("响应数据: %s", string(body))

	var response GetEmployeeListResponse
	if err := json.Unmarshal(body, &response); err != nil {
		log.Printf("解析响应数据失败: %v", err)
		return nil, err
	}

	if response.Error.Code != 0 {
		log.Printf("API返回错误: %s (错误码: %d)", response.Error.Message, response.Error.Code)
		return nil, fmt.Errorf("API错误: %s (错误码: %d)", response.Error.Message, response.Error.Code)
	}

	if response.Data.Total == 0 || len(response.Data.Items) == 0 {
		log.Printf("未找到邮箱为 %s 的员工", email)
		return nil, fmt.Errorf("未找到邮箱为 %s 的员工", email)
	}

	// 遍历员工列表，查找匹配邮箱的员工
	for _, employee := range response.Data.Items {
		if employee.Email == email {
			log.Printf("找到匹配的员工: ID=%d, 名称=%s, 邮箱=%s", employee.ID, employee.Name, employee.Email)
			return &employee, nil
		}
	}

	// 如果未找到完全匹配的邮箱，使用第一个结果
	log.Printf("未找到完全匹配的员工，使用第一个结果。ID=%d, 名称=%s", response.Data.Items[0].ID, response.Data.Items[0].Name)
	return &response.Data.Items[0], nil
}

// 查找员工
func (api *IxBrowserAPI) FindEmployee(name string) (*Employee, error) {
	log.Printf("开始调用查找员工 API, name: %s, url: %s", name, api.FindEmployeeURL)
	url := api.FindEmployeeURL

	payload := map[string]interface{}{
		"page":     1,
		"limit":    50,
		"lang":     "zh",
		"roles":    "",
		"username": name,
	}

	payloadBytes, err := json.Marshal(payload)
	if err != nil {
		return nil, err
	}

	log.Printf("查找员工 API请求数据: %s", string(payloadBytes))
	req, err := http.NewRequest("POST", url, bytes.NewBuffer(payloadBytes))
	if err != nil {
		return nil, err
	}

	req.Header.Set("Content-Type", "application/json")
	// 添加令牌头
	if api.SecToken != "" {
		req.Header.Set("X-Sec-Token", api.SecToken)
	}
	if api.Token != "" {
		req.Header.Set("X-Token", api.Token)
	}

	log.Printf("查找员工 API请求头: %v", req.Header)

	client := &http.Client{}

	resp, err := client.Do(req)
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()

	body, err := io.ReadAll(resp.Body)
	if err != nil {
		return nil, err
	}

	log.Printf("查找员工 API响应数据: %s", string(body))

	var response GetEmployeeListResponse
	if err := json.Unmarshal(body, &response); err != nil {
		return nil, err
	}

	if response.Error.Code != 0 {
		log.Printf("查找员工 API返回错误: %s", response.Error.Message)
		return nil, fmt.Errorf("API错误: %s", response.Error.Message)
	}

	if response.Data.Total == 0 || len(response.Data.Items) == 0 {
		log.Printf("找不到员工: %s", name)
		return nil, fmt.Errorf("找不到员工: %s", name)
	}

	// 返回找到的第一个员工
	log.Printf("找到员工: %s, ID: %d", response.Data.Items[0].Name, response.Data.Items[0].ID)
	return &response.Data.Items[0], nil
}

// 删除员工响应
type DeleteEmployeeResponse struct {
	Error struct {
		Code    int    `json:"code"`
		Message string `json:"message"`
		Time    int64  `json:"time"`
	} `json:"error"`
	Data interface{} `json:"data"`
}

// 删除员工
func (api *IxBrowserAPI) DeleteEmployee(employeeID int) error {
	log.Printf("开始调用删除员工API (员工ID: %d)", employeeID)

	url := fmt.Sprintf("%s?user_id=%d", api.DeleteEmployeeURL, employeeID)
	log.Printf("删除员工请求URL: %s", url)

	req, err := http.NewRequest("GET", url, nil)
	if err != nil {
		log.Printf("创建删除员工请求失败: %v", err)
		return err
	}

	// 添加令牌头
	if api.SecToken != "" {
		req.Header.Set("X-Sec-Token", api.SecToken)
	}
	if api.Token != "" {
		req.Header.Set("X-Token", api.Token)
	}

	log.Printf("删除员工请求头: %v", req.Header)

	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		log.Printf("发送删除员工请求失败: %v", err)
		return err
	}
	defer resp.Body.Close()

	log.Printf("删除员工API响应状态码: %d", resp.StatusCode)

	body, err := io.ReadAll(resp.Body)
	if err != nil {
		log.Printf("读取删除员工响应内容失败: %v", err)
		return err
	}

	log.Printf("删除员工API响应内容: %s", string(body))

	var response DeleteEmployeeResponse
	if err := json.Unmarshal(body, &response); err != nil {
		log.Printf("解析删除员工响应失败: %v", err)
		return err
	}

	if response.Error.Code != 0 {
		log.Printf("删除员工失败, 错误码: %d, 错误信息: %s", response.Error.Code, response.Error.Message)
		return fmt.Errorf("API错误: %s", response.Error.Message)
	}

	log.Printf("删除员工成功 (员工ID: %d)", employeeID)
	return nil
}

// 删除分组响应
type DeleteGroupResponse struct {
	Error struct {
		Code    int    `json:"code"`
		Message string `json:"message"`
		Time    int64  `json:"time"`
	} `json:"error"`
	Data interface{} `json:"data"`
}

// 删除分组
func (api *IxBrowserAPI) DeleteGroup(groupID int) error {
	log.Printf("开始调用删除分组API (分组ID: %d)", groupID)

	url := api.DeleteGroupURL
	log.Printf("删除分组请求URL: %s", url)

	payload := map[string]interface{}{
		"id": groupID,
	}

	payloadBytes, err := json.Marshal(payload)
	if err != nil {
		log.Printf("序列化删除分组请求数据失败: %v", err)
		return err
	}

	log.Printf("删除分组API请求数据: %s", string(payloadBytes))

	req, err := http.NewRequest("POST", url, bytes.NewBuffer(payloadBytes))
	if err != nil {
		log.Printf("创建删除分组请求失败: %v", err)
		return err
	}

	req.Header.Set("Content-Type", "application/json")
	// 添加令牌头
	if api.SecToken != "" {
		req.Header.Set("X-Sec-Token", api.SecToken)
	}
	if api.Token != "" {
		req.Header.Set("X-Token", api.Token)
	}

	log.Printf("删除分组请求头: %v", req.Header)

	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		log.Printf("发送删除分组请求失败: %v", err)
		return err
	}
	defer resp.Body.Close()

	log.Printf("删除分组API响应状态码: %d", resp.StatusCode)

	body, err := io.ReadAll(resp.Body)
	if err != nil {
		log.Printf("读取删除分组响应内容失败: %v", err)
		return err
	}

	log.Printf("删除分组API响应内容: %s", string(body))

	var response DeleteGroupResponse
	if err := json.Unmarshal(body, &response); err != nil {
		log.Printf("解析删除分组响应失败: %v", err)
		return err
	}

	if response.Error.Code != 0 {
		log.Printf("删除分组失败, 错误码: %d, 错误信息: %s", response.Error.Code, response.Error.Message)
		return fmt.Errorf("API错误: %s", response.Error.Message)
	}

	log.Printf("删除分组成功 (分组ID: %d)", groupID)
	return nil
}

// 删除浏览器响应
type DeleteBrowserResponse struct {
	Error struct {
		Code    int    `json:"code"`
		Message string `json:"message"`
		Time    int64  `json:"time"`
	} `json:"error"`
	Data interface{} `json:"data"`
}

// 删除浏览器
func (api *IxBrowserAPI) DeleteBrowser(profileID int) error {
	log.Printf("开始调用删除浏览器API (浏览器ID: %d)", profileID)

	url := api.DeleteBrowserURL
	log.Printf("删除浏览器请求URL: %s", url)

	payload := map[string]interface{}{
		"profile_id": profileID,
	}

	payloadBytes, err := json.Marshal(payload)
	if err != nil {
		log.Printf("序列化删除浏览器请求数据失败: %v", err)
		return err
	}

	log.Printf("删除浏览器API请求数据: %s", string(payloadBytes))

	req, err := http.NewRequest("POST", url, bytes.NewBuffer(payloadBytes))
	if err != nil {
		log.Printf("创建删除浏览器请求失败: %v", err)
		return err
	}

	req.Header.Set("Content-Type", "application/json")
	// 添加令牌头
	if api.SecToken != "" {
		req.Header.Set("X-Sec-Token", api.SecToken)
	}
	if api.Token != "" {
		req.Header.Set("X-Token", api.Token)
	}

	log.Printf("删除浏览器请求头: %v", req.Header)

	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		log.Printf("发送删除浏览器请求失败: %v", err)
		return err
	}
	defer resp.Body.Close()

	log.Printf("删除浏览器API响应状态码: %d", resp.StatusCode)

	body, err := io.ReadAll(resp.Body)
	if err != nil {
		log.Printf("读取删除浏览器响应内容失败: %v", err)
		return err
	}

	log.Printf("删除浏览器API响应内容: %s", string(body))

	var response DeleteBrowserResponse
	if err := json.Unmarshal(body, &response); err != nil {
		log.Printf("解析删除浏览器响应失败: %v", err)
		return err
	}

	if response.Error.Code != 0 {
		log.Printf("删除浏览器失败, 错误码: %d, 错误信息: %s", response.Error.Code, response.Error.Message)
		return fmt.Errorf("API错误: %s", response.Error.Message)
	}

	log.Printf("删除浏览器成功 (浏览器ID: %d)", profileID)
	return nil
}

// 获取分组内浏览器列表响应
type GetGroupBrowsersResponse struct {
	Error struct {
		Code    int    `json:"code"`
		Message string `json:"message"`
		Time    int64  `json:"time"`
	} `json:"error"`
	Data struct {
		Total int `json:"total"`
		Items []struct {
			ID        int    `json:"profile_id"`
			Name      string `json:"name"`
			GroupID   int    `json:"group_id"`
			GroupName string `json:"group_name"`
		} `json:"items"`
	} `json:"data"`
}

// 获取分组内的所有浏览器
func (api *IxBrowserAPI) GetGroupBrowsers(groupID int) ([]int, error) {
	url := api.GetGroupBrowsersURL

	payload := map[string]interface{}{
		"profile_id": 0,
		"name":       "",
		"group_id":   groupID,
		"tag_id":     0,
		"page":       1,
		"limit":      100, // 假设每个组最多100个浏览器
	}

	payloadBytes, err := json.Marshal(payload)
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequest("POST", url, bytes.NewBuffer(payloadBytes))
	if err != nil {
		return nil, err
	}

	req.Header.Set("Content-Type", "application/json")
	// 添加令牌头
	if api.SecToken != "" {
		req.Header.Set("X-Sec-Token", api.SecToken)
	}
	if api.Token != "" {
		req.Header.Set("X-Token", api.Token)
	}

	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()

	body, err := io.ReadAll(resp.Body)
	if err != nil {
		return nil, err
	}

	var response GetGroupBrowsersResponse
	if err := json.Unmarshal(body, &response); err != nil {
		return nil, err
	}

	if response.Error.Code != 0 {
		return nil, fmt.Errorf("API错误: %s", response.Error.Message)
	}

	// 提取所有浏览器ID
	var browserIDs []int
	for _, browser := range response.Data.Items {
		browserIDs = append(browserIDs, browser.ID)
	}

	return browserIDs, nil
}

// 获取浏览器列表响应
type GetBrowserListResponse struct {
	Error struct {
		Code    int    `json:"code"`
		Message string `json:"message"`
		Time    int64  `json:"time"`
	} `json:"error"`
	Data struct {
		Total int `json:"total"`
		Data  []struct {
			ID        int    `json:"profile_id"`
			Name      string `json:"name"`
			GroupID   int    `json:"group_id"`
			GroupName string `json:"group_name"`
			TargName  string `json:"tag_name"`
		} `json:"data"`
	} `json:"data"`
}

// 根据名称查询浏览器
func (api *IxBrowserAPI) FindBrowserByName(name string) (int, string, error) {
	url := api.GetBrowserListURL
	log.Printf("开始调用FindBrowserByName API, name: %s, url: %s", name, url)

	payload := map[string]interface{}{
		"profile_id": 0,
		"name":       name,
		"group_id":   1,
		"tag_id":     0,
		"page":       1,
		"limit":      10,
	}

	payloadBytes, err := json.Marshal(payload)
	if err != nil {
		log.Printf("序列化请求数据失败: %v", err)
		return 0, "", err
	}

	log.Printf("FindBrowserByName请求数据: %s", string(payloadBytes))

	req, err := http.NewRequest("POST", url, bytes.NewBuffer(payloadBytes))
	if err != nil {
		log.Printf("创建HTTP请求失败: %v", err)
		return 0, "", err
	}

	req.Header.Set("Content-Type", "application/json")
	// 添加令牌头
	if api.SecToken != "" {
		req.Header.Set("X-Sec-Token", api.SecToken)
	}
	if api.Token != "" {
		req.Header.Set("X-Token", api.Token)
	}

	log.Printf("发送请求到: %s, 请求头: %v", url, req.Header)

	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		log.Printf("发送HTTP请求失败: %v", err)
		return 0, "", err
	}
	defer resp.Body.Close()

	log.Printf("收到响应，状态码: %d", resp.StatusCode)

	body, err := io.ReadAll(resp.Body)
	if err != nil {
		log.Printf("读取响应数据失败: %v", err)
		return 0, "", err
	}

	log.Printf("响应数据: %s", string(body))

	var response GetBrowserListResponse
	if err := json.Unmarshal(body, &response); err != nil {
		log.Printf("解析响应数据失败: %v", err)
		return 0, "", err
	}

	if response.Error.Code != 0 {
		log.Printf("API返回错误: %s (错误码: %d)", response.Error.Message, response.Error.Code)
		return 0, "", fmt.Errorf("API错误: %s (错误码: %d)", response.Error.Message, response.Error.Code)
	}
	log.Printf("response.Data.Total: %d", response.Data.Total)
	log.Printf("response.Data.Data: %v", response.Data.Data)
	// 如果找不到匹配的浏览器
	if response.Data.Total == 0 || len(response.Data.Data) == 0 {
		log.Printf("未找到匹配的浏览器: %s", name)
		return 0, "", fmt.Errorf("未找到名称为 %s 的浏览器", name)
	}

	// 查找完全匹配的浏览器
	for _, browser := range response.Data.Data {
		if browser.Name == name {
			log.Printf("找到完全匹配的浏览器，ID: %d, 名称: %s", browser.ID, browser.Name)
			return browser.ID, browser.TargName, nil
		}
	}

	// 如果没有完全匹配的，使用第一个
	log.Printf("未找到完全匹配的浏览器，使用第一个结果。ID: %d, 名称: %s", response.Data.Data[0].ID, response.Data.Data[0].Name)
	return response.Data.Data[0].ID, response.Data.Data[0].TargName, nil
}

// 创建浏览器请求
type CreateBrowserRequest struct {
	SiteID            int                    `json:"site_id"`
	SiteURL           string                 `json:"site_url"`
	Color             string                 `json:"color"`
	Name              string                 `json:"name"`
	Note              string                 `json:"note"`
	GroupID           int                    `json:"group_id"`
	Tag               string                 `json:"tag"`
	Username          string                 `json:"username"`
	Password          string                 `json:"password"`
	Cookie            string                 `json:"cookie"`
	ProxyConfig       map[string]interface{} `json:"proxy_config"`
	FingerprintConfig map[string]interface{} `json:"fingerprint_config"`
	PreferenceConfig  map[string]interface{} `json:"preference_config"`
}

// 创建浏览器响应
type CreateBrowserResponse struct {
	Error struct {
		Code    int    `json:"code"`
		Message string `json:"message"`
		Time    int64  `json:"time"`
	} `json:"error"`
	Data json.RawMessage `json:"data"` // 浏览器ID，使用RawMessage处理多种类型
}

// 创建浏览器
func (api *IxBrowserAPI) CreateBrowser(req *CreateBrowserRequest) (int, error) {
	url := api.CreateBrowserURL
	log.Printf("开始调用CreateBrowser API, name: %s, url: %s", req.Name, url)

	payloadBytes, err := json.Marshal(req)
	if err != nil {
		log.Printf("序列化请求数据失败: %v", err)
		return 0, err
	}

	log.Printf("CreateBrowser请求数据: %s", string(payloadBytes))

	httpReq, err := http.NewRequest("POST", url, bytes.NewBuffer(payloadBytes))
	if err != nil {
		log.Printf("创建HTTP请求失败: %v", err)
		return 0, err
	}

	httpReq.Header.Set("Content-Type", "application/json")
	// 添加令牌头
	if api.SecToken != "" {
		httpReq.Header.Set("X-Sec-Token", api.SecToken)
	}
	if api.Token != "" {
		httpReq.Header.Set("X-Token", api.Token)
	}

	log.Printf("发送请求到: %s, 请求头: %v", url, httpReq.Header)

	client := &http.Client{}
	resp, err := client.Do(httpReq)
	if err != nil {
		log.Printf("发送HTTP请求失败: %v", err)
		return 0, err
	}
	defer resp.Body.Close()

	log.Printf("收到响应，状态码: %d", resp.StatusCode)

	body, err := io.ReadAll(resp.Body)
	if err != nil {
		log.Printf("读取响应数据失败: %v", err)
		return 0, err
	}

	log.Printf("响应数据: %s", string(body))

	var response CreateBrowserResponse
	if err := json.Unmarshal(body, &response); err != nil {
		log.Printf("解析响应数据失败: %v", err)
		return 0, err
	}

	if response.Error.Code != 0 {
		log.Printf("API返回错误: %s (错误码: %d)", response.Error.Message, response.Error.Code)
		return 0, fmt.Errorf("API错误: %s (错误码: %d)", response.Error.Message, response.Error.Code)
	}

	// 尝试解析data为整数
	var browserID int
	if err := json.Unmarshal(response.Data, &browserID); err != nil {
		log.Printf("解析浏览器ID失败: %v, 原始数据: %s", err, string(response.Data))
		return 0, fmt.Errorf("解析响应数据失败: %v", err)
	}

	log.Printf("成功创建浏览器，浏览器ID: %d", browserID)
	return browserID, nil
}

// 更新浏览器请求
type UpdateBrowserRequest struct {
	ProfileID         int                    `json:"profile_id"`
	NewProfileID      int                    `json:"new_profile_id,omitempty"`
	SiteID            int                    `json:"site_id,omitempty"`
	SiteURL           string                 `json:"site_url,omitempty"`
	Color             string                 `json:"color,omitempty"`
	Name              string                 `json:"name,omitempty"`
	Note              string                 `json:"note,omitempty"`
	GroupID           int                    `json:"group_id,omitempty"`
	Tag               string                 `json:"tag,omitempty"`
	Username          string                 `json:"username,omitempty"`
	Password          string                 `json:"password,omitempty"`
	Cookie            string                 `json:"cookie,omitempty"`
	ProxyConfig       map[string]interface{} `json:"proxy_config,omitempty"`
	FingerprintConfig map[string]interface{} `json:"fingerprint_config,omitempty"`
	PreferenceConfig  map[string]interface{} `json:"preference_config,omitempty"`
}

// 更新浏览器响应
type UpdateBrowserResponse struct {
	Error struct {
		Code    int    `json:"code"`
		Message string `json:"message"`
		Time    int64  `json:"time"`
	} `json:"error"`
	Data interface{} `json:"data"`
}

// 更新浏览器
func (api *IxBrowserAPI) UpdateBrowser(req *UpdateBrowserRequest) error {
	url := api.UpdateBrowserURL
	log.Printf("开始调用UpdateBrowser API, profileID: %d, url: %s", req.ProfileID, url)

	payloadBytes, err := json.Marshal(req)
	if err != nil {
		log.Printf("序列化请求数据失败: %v", err)
		return err
	}

	log.Printf("UpdateBrowser请求数据: %s", string(payloadBytes))

	httpReq, err := http.NewRequest("POST", url, bytes.NewBuffer(payloadBytes))
	if err != nil {
		log.Printf("创建HTTP请求失败: %v", err)
		return err
	}

	httpReq.Header.Set("Content-Type", "application/json")
	// 添加令牌头
	if api.SecToken != "" {
		httpReq.Header.Set("X-Sec-Token", api.SecToken)
	}
	if api.Token != "" {
		httpReq.Header.Set("X-Token", api.Token)
	}

	log.Printf("发送请求到: %s, 请求头: %v", url, httpReq.Header)

	client := &http.Client{}
	resp, err := client.Do(httpReq)
	if err != nil {
		log.Printf("发送HTTP请求失败: %v", err)
		return err
	}
	defer resp.Body.Close()

	log.Printf("收到响应，状态码: %d", resp.StatusCode)

	body, err := io.ReadAll(resp.Body)
	if err != nil {
		log.Printf("读取响应数据失败: %v", err)
		return err
	}

	log.Printf("响应数据: %s", string(body))

	var response UpdateBrowserResponse
	if err := json.Unmarshal(body, &response); err != nil {
		log.Printf("解析响应数据失败: %v", err)
		return err
	}

	if response.Error.Code != 0 {
		log.Printf("API返回错误: %s (错误码: %d)", response.Error.Message, response.Error.Code)
		return fmt.Errorf("API错误: %s (错误码: %d)", response.Error.Message, response.Error.Code)
	}

	log.Printf("成功更新浏览器 (ID: %d)", req.ProfileID)
	return nil
}

// 更新浏览器代理请求
type UpdateBrowserProxyRequest struct {
	ProfileID int `json:"profile_id"`
	ProxyInfo struct {
		ProxyMode      int    `json:"proxy_mode"`
		ProxyCheckLine string `json:"proxy_check_line"`
		ProxyType      string `json:"proxy_type"`
		ProxyIP        string `json:"proxy_ip"`
		ProxyPort      string `json:"proxy_port"`
		ProxyUser      string `json:"proxy_user"`
		ProxyPassword  string `json:"proxy_password"`
	} `json:"proxy_info"`
}

// 更新浏览器代理响应
type UpdateBrowserProxyResponse struct {
	Error struct {
		Code    int    `json:"code"`
		Message string `json:"message"`
		Time    int64  `json:"time"`
	} `json:"error"`
	Data interface{} `json:"data"`
}

// 更新浏览器代理
func (api *IxBrowserAPI) UpdateBrowserProxy(req *UpdateBrowserProxyRequest) error {
	url := api.UpdateBrowserProxyURL
	log.Printf("开始调用UpdateBrowserProxy API, profileID: %d, url: %s", req.ProfileID, url)

	payloadBytes, err := json.Marshal(req)
	if err != nil {
		log.Printf("序列化请求数据失败: %v", err)
		return err
	}

	log.Printf("UpdateBrowserProxy请求数据: %s", string(payloadBytes))

	httpReq, err := http.NewRequest("POST", url, bytes.NewBuffer(payloadBytes))
	if err != nil {
		log.Printf("创建HTTP请求失败: %v", err)
		return err
	}

	httpReq.Header.Set("Content-Type", "application/json")
	// 添加令牌头
	if api.SecToken != "" {
		httpReq.Header.Set("X-Sec-Token", api.SecToken)
	}
	if api.Token != "" {
		httpReq.Header.Set("X-Token", api.Token)
	}

	log.Printf("发送请求到: %s, 请求头: %v", url, httpReq.Header)

	client := &http.Client{}
	resp, err := client.Do(httpReq)
	if err != nil {
		log.Printf("发送HTTP请求失败: %v", err)
		return err
	}
	defer resp.Body.Close()

	log.Printf("收到响应，状态码: %d", resp.StatusCode)

	body, err := io.ReadAll(resp.Body)
	if err != nil {
		log.Printf("读取响应数据失败: %v", err)
		return err
	}

	log.Printf("响应数据: %s", string(body))

	var response UpdateBrowserProxyResponse
	if err := json.Unmarshal(body, &response); err != nil {
		log.Printf("解析响应数据失败: %v", err)
		return err
	}

	if response.Error.Code != 0 {
		log.Printf("API返回错误: %s (错误码: %d)", response.Error.Message, response.Error.Code)
		return fmt.Errorf("API错误: %s (错误码: %d)", response.Error.Message, response.Error.Code)
	}

	log.Printf("成功更新浏览器代理 (浏览器ID: %d)", req.ProfileID)
	return nil
}

// 获取标签列表请求
type GetTagListRequest struct {
	Page  int    `json:"page"`
	Limit int    `json:"limit"`
	Title string `json:"title,omitempty"`
}

// 获取标签列表响应
type GetTagListResponse struct {
	Error struct {
		Code    int    `json:"code"`
		Message string `json:"message"`
		Time    int64  `json:"time"`
	} `json:"error"`
	Data struct {
		Total int `json:"total"`
		Items []struct {
			ID    int    `json:"id"`
			Title string `json:"title"`
		} `json:"items"`
	} `json:"data"`
}

// 获取标签列表
func (api *IxBrowserAPI) GetTagList(req *GetTagListRequest) (*GetTagListResponse, error) {
	url := api.GetTagListURL
	log.Printf("开始调用GetTagList API, url: %s", url)

	payloadBytes, err := json.Marshal(req)
	if err != nil {
		log.Printf("序列化请求数据失败: %v", err)
		return nil, err
	}

	log.Printf("GetTagList请求数据: %s", string(payloadBytes))

	httpReq, err := http.NewRequest("POST", url, bytes.NewBuffer(payloadBytes))
	if err != nil {
		log.Printf("创建HTTP请求失败: %v", err)
		return nil, err
	}

	httpReq.Header.Set("Content-Type", "application/json")
	// 添加令牌头
	if api.SecToken != "" {
		httpReq.Header.Set("X-Sec-Token", api.SecToken)
	}
	if api.Token != "" {
		httpReq.Header.Set("X-Token", api.Token)
	}

	log.Printf("发送请求到: %s, 请求头: %v", url, httpReq.Header)

	client := &http.Client{}
	resp, err := client.Do(httpReq)
	if err != nil {
		log.Printf("发送HTTP请求失败: %v", err)
		return nil, err
	}
	defer resp.Body.Close()

	log.Printf("收到响应，状态码: %d", resp.StatusCode)

	body, err := io.ReadAll(resp.Body)
	if err != nil {
		log.Printf("读取响应数据失败: %v", err)
		return nil, err
	}

	log.Printf("响应数据: %s", string(body))

	var response GetTagListResponse
	if err := json.Unmarshal(body, &response); err != nil {
		log.Printf("解析响应数据失败: %v", err)
		return nil, err
	}

	if response.Error.Code != 0 {
		log.Printf("API返回错误: %s (错误码: %d)", response.Error.Message, response.Error.Code)
		return nil, fmt.Errorf("API错误: %s (错误码: %d)", response.Error.Message, response.Error.Code)
	}

	log.Printf("成功获取标签列表，总数: %d", response.Data.Total)
	return &response, nil
}
